MMA51xx.c

Go to the documentation of this file.

#include "derivative.h"
#include "Compile_Options.h"
#include "CG147.h"
#include "MMA51xx.h"
/*
 ******************************************************************************
 * Constants
 ******************************************************************************
 */

/*
 ******************************************************************************
 * Globals
 ******************************************************************************
 */
static uint8_t gu8MMA5100Settings;
static uint8_t gu8MMA5100IndexAdder;

uint16_t u16fnMMA5100TreatData(uint16_t* pu16SatData,
                               uint8_t* pu8ResultArray,
                               uint8_t* pu8CurrentIndex,
                               uint8_t* pu8IndexAdder,
                               uint32_t* pu32AlreadyWritten)
{
  /* Locals */
  uint16_t u16Status;
  
  /* Init locals */
  u16Status = CLEAR;
  
  /* Verify that the gathered data is not an accel value */
  if((*pu16SatData < MMA5100_UL_FOR_DATA) & *pu16SatData > MMA5100_LL_FOR_DATA)
  {
    /* Verify that the gathered data is in fact data */
    if(*pu16SatData & MMA5100_DATA_INDICATOR)
    {
      /* We have data */
      gu8MMA5100Settings = (uint8_t)(*pu16SatData & MMA5100_CONTENTS_MASK);
      switch(*pu8CurrentIndex)
      {
        case (MMA5100_D1):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D1)) == CLEAR)
          {
            pu8ResultArray[PROTOCOL] = gu8MMA5100Settings;
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D1);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D2):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D2)) == CLEAR)
          {
            pu8ResultArray[N_DATA_BLOCKS] = (gu8MMA5100Settings
                << BITS_IN_NIBBLE);
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D2);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D3):
        {
          
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D3)) == CLEAR)
          {
            pu8ResultArray[N_DATA_BLOCKS] &= 0xF0u;
            pu8ResultArray[N_DATA_BLOCKS] |= gu8MMA5100Settings;
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D3);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D4):
        {
          
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D4)) == CLEAR)
          {
            pu8ResultArray[MANUFACTURER] = (gu8MMA5100Settings
                << BITS_IN_NIBBLE);
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D4);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D5):
        {
          
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D5)) == CLEAR)
          {
            pu8ResultArray[MANUFACTURER] &= 0xF0u;
            pu8ResultArray[MANUFACTURER] |= gu8MMA5100Settings;
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D5);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D6):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D6)) == CLEAR)
          {
            pu8ResultArray[SENSOR_TYPE]
                = (gu8MMA5100Settings << BITS_IN_NIBBLE);
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D6);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D7):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D7)) == CLEAR)
          {
            pu8ResultArray[SENSOR_TYPE] &= 0xF0u;
            pu8ResultArray[SENSOR_TYPE] |= gu8MMA5100Settings;
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D7);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D8):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D8)) == CLEAR)
          {
            pu8ResultArray[AXIS] = gu8MMA5100Settings;
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D8);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D9):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D9)) == CLEAR)
          {
            pu8ResultArray[RANGE] = gu8MMA5100Settings;
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D9);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D10):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D10)) == CLEAR)
          {
            pu8ResultArray[DEVCFG2] = (gu8MMA5100Settings << BITS_IN_NIBBLE);
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D10);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D11):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D11)) == CLEAR)
          {
            pu8ResultArray[DEVCFG2] &= 0xF0u;
            pu8ResultArray[DEVCFG2] |= gu8MMA5100Settings;
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D11);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D12):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D12)) == CLEAR)
          {
            pu8ResultArray[PRODUCT_REVISION] = (gu8MMA5100Settings
                << BITS_IN_NIBBLE);
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D12);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D13):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D13)) == CLEAR)
          {
            pu8ResultArray[PRODUCT_REVISION] &= 0xF0u;
            pu8ResultArray[PRODUCT_REVISION] |= gu8MMA5100Settings;
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D13);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D14):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D14)) == CLEAR)
          {
            pu8ResultArray[DEVCFG6] = gu8MMA5100Settings;
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D14);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D15):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D15)) == CLEAR)
          {
            pu8ResultArray[PROD_DATE_1]
                = (gu8MMA5100Settings << BITS_IN_NIBBLE);
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D15);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D16):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D16)) == CLEAR)
          {
            pu8ResultArray[PROD_DATE_1] &= 0xF0u;
            pu8ResultArray[PROD_DATE_1] |= gu8MMA5100Settings;
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D16);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D17):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D17)) == CLEAR)
          {
            pu8ResultArray[PROD_DATE_2]
                = (gu8MMA5100Settings << BITS_IN_NIBBLE);
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D17);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D18):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D18)) == CLEAR)
          {
            pu8ResultArray[PROD_DATE_2] &= 0xF0u;
            pu8ResultArray[PROD_DATE_2] |= gu8MMA5100Settings;
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D18);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D19):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D19)) == CLEAR)
          {
            pu8ResultArray[SN0] = (gu8MMA5100Settings << BITS_IN_NIBBLE);
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D19);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D20):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D20)) == CLEAR)
          {
            pu8ResultArray[SN0] &= 0xF0u;
            pu8ResultArray[SN0] |= gu8MMA5100Settings;
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D20);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D21):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D21)) == CLEAR)
          {
            pu8ResultArray[SN1] = (gu8MMA5100Settings << BITS_IN_NIBBLE);
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D21);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D22):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D22)) == CLEAR)
          {
            pu8ResultArray[SN1] &= 0xF0u;
            pu8ResultArray[SN1] |= gu8MMA5100Settings;
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D22);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D23):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D23)) == CLEAR)
          {
            pu8ResultArray[SN2] = (gu8MMA5100Settings << BITS_IN_NIBBLE);
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D23);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D24):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D24)) == CLEAR)
          {
            pu8ResultArray[SN2] &= 0xF0u;
            pu8ResultArray[SN2] |= gu8MMA5100Settings;
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D24);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D25):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D25)) == CLEAR)
          {
            pu8ResultArray[SN3] = (gu8MMA5100Settings << BITS_IN_NIBBLE);
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D25);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D26):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D26)) == CLEAR)
          {
            pu8ResultArray[SN3] &= ((uint8_t)0xF0u);
            pu8ResultArray[SN3] |= gu8MMA5100Settings;
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D26);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D27):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D27)) == CLEAR)
          {
            pu8ResultArray[INIT_RAW_OFFSET] = gu8MMA5100Settings;
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D27);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D28):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D28)) == CLEAR)
          {
            pu8ResultArray[INIT_RAW_OFFSET] &= ((uint8_t)0x0Fu);
            pu8ResultArray[INIT_RAW_OFFSET] |= (gu8MMA5100Settings
                << BITS_IN_NIBBLE);
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D28);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D29):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D29)) == CLEAR)
          {
            pu8ResultArray[COMBINED_OFFSET_SELF_TEST] = gu8MMA5100Settings;
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D29);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D30):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D30)) == CLEAR)
          {
            pu8ResultArray[AVG_SELF_TEST] = gu8MMA5100Settings;
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D30);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D31):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D31)) == CLEAR)
          {
            pu8ResultArray[AVG_SELF_TEST] &= ((uint8_t)0x0Fu);
            pu8ResultArray[AVG_SELF_TEST] |= (gu8MMA5100Settings
                << BITS_IN_NIBBLE);
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D31);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        case (MMA5100_D32):
        {
          if((*pu32AlreadyWritten & (BIT0 << MMA5100_D32)) == CLEAR)
          {
            pu8ResultArray[DEVCFG1] = gu8MMA5100Settings;
            *pu32AlreadyWritten |= (BIT0 << MMA5100_D32);
          }
          else
          {
            /* Nothing */
          }
          break;
        }
        default:
        {
          u16Status = MMA5100_COMMAND_NOT_RECOGNIZED;
          break;
        }
      }
    }
    else
    {
      /* This is an index. Let's store it. */
      *pu8CurrentIndex = ((uint8_t)(*pu16SatData & MMA5100_CONTENTS_MASK)
          + *pu8IndexAdder);
      
      /* Remember if we need to go to the second page */
      if(*pu8CurrentIndex == MMA5100_D16)
      {
        *pu8IndexAdder = MMA5100_D17;
      }
      else
      {
        /* Nothing */
      }
    }
  }
  else
  {
    /* This is not data; it's a status word */
    switch(*pu16SatData)
    {
      case (MMA5100_SENSOR_DEFECT):
      {
        u16Status = MMA5100_SENSOR_DEFECT_STATUS;
        break;
      }
      case (MMA5100_SENSOR_BUSY):
      {
        u16Status = MMA5100_SENSOR_BUSY_STATUS;
        break;
      }
      case (MMA5100_SENSOR_READY):
      {
        u16Status = MMA5100_SENSOR_READY_STATUS;
        break;
      }
      case (MMA5100_SENSOR_READY_UNLOCKED):
      {
        u16Status = MMA5100_SENSOR_READY_UNLOCKED_STATUS;
        break;
      }
      default:
      {
        u16Status = MMA5100_COMMAND_NOT_RECOGNIZED;
        break;
      }
    }
    
  }
  
  return (u16Status);
}
/*
 ******************************************************************************
 *
 *  End of file.
 *
 ******************************************************************************
 */